﻿#define _CRT_SECURE_NO_WARNINGS

#include<iostream>
#include<vector>
using namespace std;
class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base2, public Base1 { public: int _d; };
int main()
{
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;
	cout << p1 << endl;
	cout << p2 << endl;
	cout << p3 << endl;
	return 0;
}
//class Base1 { public: int _b1; };
//class Base2 { public: int _b2; };
//class Derive : public Base1, public Base2 { public: int _d; };
//int main()
//{
//	Derive d;
//	Base1* p1 = &d;
//	Base2* p2 = &d;
//	Derive* p3 = &d;
//	cout << p1 << endl;
//	cout << p2 << endl;
//	cout << p3 << endl;
//	return 0;
//}
//namespace xiaodu
//{
//	//template<class T>
//	//class vector
//	//{ };
//	// stack和vector的关系，既符合is-a，也符合has-a
//	template<class T>
//	class stack : public std::vector<T>//继承类模板
//	{
//	public:
//		void push(const T& x)
//		{
//			// 基类是类模板时，需要指定⼀下类域
//			// 否则编译报错:error C3861: “push_back”: 找不到标识符
//			// 因为stack<int>实例化时，也实例化vector<int>了——继承关系
//// 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到
//			vector<T>::push_back(x);//指定类域
//			//push_back(x);
//		}
//		void pop()
//		{
//			vector<T>::pop_back();
//		}
//		const T& top()
//		{
//			return vector<T>::back();
//		}
//		bool empty()
//		{
//			return vector<T>::empty();
//		}
//	};
//}
//int main()
//{
//	xiaodu::stack<int> st;//stack<int>实例化时，也实例化vector<int>
//	st.push(1);
//	st.push(2);
//	st.push(3);
//	while (!st.empty())
//	{
//		cout << st.top() << " ";
//		st.pop();
//	}
//	return 0;
//}
////// Tire(轮胎)和Car(车)更符合has-a的关系
//class Tire
//{
//protected:
//	string _brand = "MM"; // 品牌
//	size_t _size = 17; // 尺⼨
//};
//class Car 
//{
//protected:
//	string _colour = "黑色"; //颜色
//	Tire _t1; // 轮胎
//	Tire _t2; // 轮胎
//	Tire _t3; // 轮胎
//	Tire _t4; // 轮胎
//};
////虚继承
//class A
//{
//public:
//	int _a;
//};
//class B :virtual public A
//{
//public:
//	int _b;
//};
//class C :virtual public A
//{
//public:
//	int _c;
//};
//class D :public B, public C
//{
//public:
//	int _d;
//};
//int main()
//{
//	D d;
//	d._a = 1;//解决了二义性和数据冗余问题
//	d.B::_a = 2;
//	d.C::_a = 3;
//	//通过虚继承，无论通过多少条路径，确保派生类只继承基类的一个副本
//	cout << d._a << endl;
//	cout << d.C::_a << endl;
//	return 0;
//}

////菱形继承
//class A
//{
//public:
//	int _a;
//};
//class B :public A
//{
//public:
//	int _b;
//};
//class C :public A
//{
//public:
//	int _c;
//};
//class D :public B, public C
//{
//public:
//	int _d;
//};
//int main()
//{
//	D d;
//	//d._a = 2;//err D::_a不明确 —— 存在二义性
//	//解决方法——显示指定访问哪一个基类，但是数据冗余问题无法解决
//	d.B::_a = 2;
//	d.C::_a = 3;
//	//在两个类分别拷贝了一次，依然存在数据冗余
//	cout << d.B::_a << endl;
//	cout << d.C::_a << endl;
//	return 0;
//}
//class Base1
//{
//public:
//    int _a;
//};
//
//class Base2
//{
//public:
//    int _b;
//};
//
//class Derived1 : public Base1,public Base2//一个派生类有两个或更多直接基类——多继承
//{
//
//};
//class Derived2 : public Base1//单继承
//{
//
//};
//
//class Base 
//{
//public:
//    int _a;
//    static int _count;//基类有一个静态成员变量
//};
//
//int Base::_count = 0; // 静态成员变量的定义和初始化
//
//class Derived1 : public Base 
//{
//
//};
//class Derived2 : public Base 
//{
//
//};
//
//int main() {
//    Base b1, b2;
//    Derived1 d1;
//    Derived2 d2;
//
//    b1._count++; // 访问并修改静态成员
//    d1._count++; // 同样访问的是Base::count，因为静态成员在继承体系中是共享的
//
//    std::cout << "Base count: " << b1._count << std::endl; // 输出2
//    std::cout << "Base count: " << b2._count << std::endl; // 输出2
//    std::cout << "Derived1 count: " << d1._count << std::endl; // 输出2，因为访问的是同一个静态成员
//    std::cout << "Derived2 count: " << d1._count << std::endl; // 输出2，因为访问的是同一个静态成员
//    //证明：打印地址是一样的
//    //静态成员在继承体系中是共享的
//    cout << &b1._count << endl;
//    cout << &b2._count << endl;
//    cout << &d1._count << endl;
//    cout << &d2._count << endl << endl;
//    //非静态成员在继承体系中不共享，地址不一样
//    cout << &b1._a << endl;
//    cout << &d1._a << endl;
//    return 0;
//}

//class B;//前向声明B类,说明有这个类
//class A
//{
//public:
//	friend void show(const A& a, const B& b);
//	A(int a) :_a(a)
//	{
//
//	}
//protected:
//	int _a;
//};
//class B :public A
//{
//public:
//	friend void show(const A& a, const B& b);
//	//让友元关系在派生类也存在
//	B(int a, int b) :A(a), _b(b)
//	{
//
//	}
//protected:
//	int _b;
//};
//void show(const A& a, const B& b) 
//{
//	cout << "show()" << endl;
//	cout << a._a << endl;
//	cout << b._b << endl;//基类的友元不能自动访问派生类的私有和保护成员
//	//解决方法：让友元关系在派生类也是存在的
//}
//
//int main()
//{
//
//	B b(1, 2);
//	show(b, b);
//	return 0;
//}
////实现一个不能被继承的类
//// C++11的方法——声明为final的类无法被其他类继承，编译器将直接报错
//class Base final
//{
//public:
//	void func1() { cout << "Base::func1" << endl; }
//protected:
//	int a = 1;
//private:
//	// C++98的方法——构造函数私有
//	/*Base()
//	{}*/
//};
//class Derive :public Base
//{
//	void func2() { cout << "Derive::func2" << endl; }
//protected:
//	int b = 2;
//};
//int main()
//{
//	Base b;
//	Derive d;
//	return 0;
//}
////基类Animal
//class Animal
//{
//public:
//    string _name;
//    int _age;
//    //基类构造函数
//    Animal(string name, int age):_name(name),_age(age)
//    {
//        cout << "基类Animal构造" << endl;
//    }
//    //基类拷贝构造
//    Animal(const Animal& a):_name(a._name),_age(a._age)
//    {
//        cout << "Animal拷贝构造" << endl;
//    }
//    //基类赋值运算符重载
//    Animal& operator=(const Animal& a)
//    {
//       
//        //不是本身才进行赋值
//        if (this != &a)
//        {
//            _name = a._name;
//            _age = a._age;
//        }
//        cout << "Animal 赋值运算符重载" << endl;
//        return *this;
//    }
//    void eat()
//    {
//        cout << " Animal " << _name << " is eating." << endl;
//    }
//
//    void sleep() 
//    {
//        cout << " Animal " << _name << " is sleeping." << endl;
//    }
//    //基类析构函数
//    ~Animal()
//    {
//        cout << "~Animal" << endl;
//    }
//};
//
////派生类
//class Dog : public Animal
//{
//public:
//    int _id;
//    //派生类构造函数
//    //Dog(string name,int age,int id):_name(name),_age(age),_id(id)//err 这种写法是错误的
//   //基类没有提供默认构造函数（即无参构造函数），则派生类构造函数需在初始化列表中显式调用基类的某个构造函数
//    //正确写法
//    Dog(string name, int age, int id) :Animal(name, age), _id(id)
//    {
//        cout << "派生类Dog构造" << endl;
//    }
//
//    //派生类拷贝构造
//    //这里派生类和基类之间的转换就发生了大作用
//    Dog(const Dog& d) :Animal(d), _id(d._id)
//    {
//        cout << "Dog 拷贝构造" << endl;
//    }
//    //派生类赋值运算符重载
//    Dog& operator=(const Dog& d)
//    {
//        //派生类的赋值运算符在对象赋值时，必须调用基类的赋值运算符来完成基类成员的更新
//       // 派生类的赋值运算符会隐藏基类的赋值运算符
//       // 因此调用基类赋值运算符时，需显式指定基类作用域
//        if (this != &d)
//        {
//            Animal::operator=(d);//显式指定基类作用域
//            _id = d._id;
//        }
//        cout << "Dog 赋值运算符重载" << endl;
//        return *this;
//    }
//    void bark()
//    {
//        cout << " Dog " << _name << " is barking." << endl;
//    }
//    //派生类析构函数
//    ~Dog()
//    {
//        cout << "~Dog()" << endl;
//    }
//};
//
//
//
//int main()
//{
//    Dog d1("DD", 6, 1);
//    //先初始化基类，再初始化派生类
//    Dog d2 = d1;//调用拷贝构造
//    Dog d3("DD3", 8, 2);
//    d3 = d1;
//    //先析构派生类，再析构基类
//    return 0;
//}







////基类Animal
//class Animal
//{
//public:
//    string _name;
//    int _age;
//
//    void eat() {
//        cout << _name << " is eating." << endl;
//    }
//
//    void sleep() {
//        cout << _name << " is sleeping." << endl;
//    }
//};
//
////子类
//class Dog :public Animal
//{
//public:
//    void bark() 
//    {
//        cout << _name << " is barking." << endl;
//    }
//};
//
//class Bird : public Animal {
//public:
//    void fly()
//    {
//        cout << _name << " is flying." << endl;
//    }
//};
//int main()
//{
//    Dog d;
//    Bird b;
//    d.bark();
//    b.fly();
//	return 0;
//}

////基类Animal
//class Animal
//{
//public:
//    string _name;
//    int _age;
//
//    void eat() {
//        cout << _name << " is eating." << endl;
//    }
//
//    void sleep() {
//        cout << _name << " is sleeping." << endl;
//    }
//};
//
////子类
//class Dog : Animal//class关键字，继承方式为private
//{
//public:
//    void bark()
//    {
//        cout << _name << " is barking." << endl;
//    }
//};
//
//struct Bird : Animal //struct关键字，继承方式为public
//{
//public:
//    void fly()
//    {
//        cout << _name << " is flying." << endl;
//    }
//};
//int main()
//{
//    Dog d;
//    //d._name = "DD";//err
//    //d._age = 6;//err
//    //d.eat();//err 
//    //class 关键字，不显示写继承方式默认为private
//    //除基类的私有成员外，其他成员在派生类中的访问方式
//    //取决于成员在基类中的访问限定符和继承方式的最小值（Min），这里是private
//    d.bark();
//    Bird b;
//    b._name = "BB";
//    b._age = 3;
//    b.eat();
//    b.fly();
//    return 0;
//}

////基类Animal
//class Animal
//{
//public:
//    string _name;
//    int _age;
//
//    void eat() {
//        cout << _name << " is eating." << endl;
//    }
//
//    void sleep() {
//        cout << _name << " is sleeping." << endl;
//    }
//};
//
////子类
//class Dog : public Animal
//{
//public:
//    void bark()
//    {
//        cout << _name << " is barking." << endl;
//    }
//};
//
//struct Bird : public Animal 
//{
//public:
//    void fly()
//    {
//        cout << _name << " is flying." << endl;
//    }
//};
//int main()
//{
//    Dog d;
//    d._name = "DD";
//    d._age = 6;
//    d.eat();
//    d.bark();
//    Bird b;
//    b._name = "BB";
//    b._age = 3;
//    b.eat();
//    b.fly();
//
//    //1.派生类对象可以赋值给基类
//    Animal a1;
//    a1 = d;
//    a1.eat();
//   // a1.bark();//err 父类没有这个成员函数
//    Animal a2;
//    a2 = b;
//    a2.eat();
//   // a2.fly();//err 父类没有这个成员函数
//    //2.派生类对象可以赋值给基类的指针/引用
//    Animal* aa1 = &d;
//    Animal& aa2 = d;
//    Dog* dp = &d;
//    cout << aa1 << endl;
//    cout << dp << endl;//这也就是同一个地址
//
//    //3.基类对象不可以赋值给派生类
//   // d = a1;//这里编译报错
//    return 0;
//}

////基类Animal
//class Animal
//{
//public:
//    string _name;
//    int _age;
//
//    void eat()
//    {
//        cout << " Animal " << _name << " is eating." << endl;
//    }
//
//    void sleep() 
//    {
//        cout << " Animal " << _name << " is sleeping." << endl;
//    }
//};
//
////子类
//class Dog : public Animal
//{
//public:
//    void bark()
//    {
//        cout << " Dog " << _name << " is barking." << endl;
//    }
//
//    void bark(int a)
//    {
//        cout << a << " Dog " << _name << " is barking." << endl;
//    }
//    //一个类中函数名相同，但是函数参数类型或者个数不同就构成函数重载
//
//    //隐藏只要函数名相同就构成
//    void eat()
//    {
//        cout << " Dog " << _name << " is eating." << endl;
//    }
//};
//
//struct Bird : public Animal 
//{
//public:
//    void fly()
//    {
//        cout << " Bird " << _name << " is flying." << endl;
//    }
//};
//
//int main()
//{
//    Dog d;
//    d._name = "DD";
//    d._age = 6;
//    d.bark();
//    d.bark(3);//函数重载
//
//    d.eat();//函数隐藏——调用派生类，而不是基类
//    d.Animal::eat();//使用“基类::基类成员”的方式来显式访问被隐藏的基类成员
//    d.sleep();//调用基类的
//    return 0;
//}

//class A
//{
//public:
//	void func()
//	{
//		cout << "func()" << endl;
//	}
//};
//class B : public A
//{
//public:
//	void func(int i)
//	{
//		cout << "func(int i)" << i << endl;
//	}
//};
//int main()
//{
//	B b;
//	b.func(10);
//	//b.func();//err 函数隐藏
//	return 0;
//};